#include <inctypes.h>
#include <incctrls.h>

/* initialize structure */

/*********************************************************************************
 * 
 * kmempool_init - 初始化 oskmempool 全局变量
 * 
 * DESCRIPTION
 * 
 */

void kmempool_init (void)
    {
    kmempool_t_init (&oskmempool);

    return;
    }

/*********************************************************************************
 * 
 * kmempool_t_init - 初始化 kmempool_t 结构体
 * 
 * DESCRIPTION
 * 
 */

void kmempool_t_init
    (
    kmempool_t * initp
    )
    {
    spinlock_init (&initp->lock);
    list_init (&initp->list);

    initp->status = 0;
    initp->flags  = 0;

    spinlock_init (&initp->pagelock);
    spinlock_init (&initp->bytelock);

    initp->pagepoolnbr = 0;
    initp->bytepoolnbr = 0;

    /* 初始化 内存池的链表 */

    list_init (&initp->pagepoolheadlst);
    list_init (&initp->bytepoolheadlst);

    initp->lastoppagepool = NULL;
    initp->lastopbytepool = NULL;

    return;
    }

/*********************************************************************************
 * 
 * mempoolhead_t_init - 初始化一个新的内存池
 * 
 * DESCRIPTION
 * 
 */

void mempoolhead_t_init
    (
    mempoolhead_t * initp
    )
    {
    spinlock_init (&initp->lock);     /* 初始化自旋锁 */
    list_init (&initp->list);         /* 初始化链表 */

    initp->type              = KMEMP_HDTYPE_NA; /* 类型初始化为未知 */
    initp->addrstart         = NULL;            /* 所管理的内存起始地址 */
    initp->addrend           = NULL;            /* 所管理的内存结束地址 */
    initp->firstfreepagedsc  = NULL;
    initp->firstfreeobjaddr  = NULL;
    initp->objtotnbr         = 0;
    initp->objsz             = 0;
    initp->objactlsz         = 0;
    initp->objallocednbr     = 0;

    /* mempagedsc 作为 mempoolhead_t 结构体的最后一个成员 (数据结构决定的) */

    initp->mempagedscnbr     = 0;
    initp->mempagedsc        = (mempagedsc_t *) ((uint_t) initp + sizeof (mempoolhead_t));

    return;
    }

/* base for new and free */

/*********************************************************************************
 * 
 * kmempool_page_init - 创建 mempoolhead_t 并 初始化 再 挂载到 kmempool_t 容器
 * 
 * DESCRIPTION
 * 1.初始化并建立 mempoolhead_t 结构
 * 2.初始化并建立 mempagedsc_t 结构 (最后一个 mempagedsc_t 的 next 域 设为 NULL)
 * 3.根据 mempagedsc_t 结构的情况再设置 mempoolhead_t 结构的信息, 并把这个内存池
 *   (mempoolhead_t 结构) 加入到 kmempool_t 结构的 pagepoolheadlst 域中
 * 
 */

mempoolhead_t * kmempool_page_init
    (
    kmempool_t *    kmempool,
    mempoolhead_t * mempoolhead,
    size_t          size,
    addr_t          addrstart,
    addr_t          addrend
    )
    {
    addr_t    ofstaddr;
    uint_t    pagenbr;

    /* 
     * (起始地址不是 KMEMP_ONEPAGE_SZ - 1 字节对齐) 或 
     * (地址区间不足以分配两个页以上 (内核在每个内存池固定占1页)) 
     */

    if (((addrstart & 0xFFF) != 0) || ((addrend - addrstart) < ((KMEMP_ONEPAGE_SZ * 2) - 1)))
        {
        return NULL;
        }
    
    /* 内存空间第一页 要存放 mempoolhead_t */

    ofstaddr = addrstart + KMEMP_ONEPAGE_SZ;

    /* mempoolhead_t 结构体初始化 */

    mempoolhead_t_init (mempoolhead);                   /* 默认初始化 */
    mempoolhead->type              = KMEMP_HDTYPE_PAGE; /* 类型为页级 */
    mempoolhead->addrstart         = addrstart;         /* 内存池内存起始地址 */
    mempoolhead->addrend           = addrend;           /* 内存池内存结束地址 */
    mempoolhead->objsz             = size;              /* 内存池对象 (页) 的大小 */
    mempoolhead->objactlsz         = size;              /* 内存池对象 (页) 的实际大小 (页级中等于objsz) */

    pagenbr = 0;

    /* 将 地址区间的空间 全部映射为 mempoolhead_t 结构体管理的 页 */    

    FOREVER
        {

        /* 剩余空间 不足以分配 size 大小的空间 */

        if ((ofstaddr + size - 1) > addrend)
            {
            break;
            }

        mempoolhead->mempagedsc[pagenbr].addrstart = ofstaddr;
        mempoolhead->mempagedsc[pagenbr].next      = &(mempoolhead->mempagedsc[pagenbr + 1]);

        ofstaddr += size;       /* 循环一次 地址偏移 size */
        pagenbr++;              /* 该 mempoolhead_t 结构体 管理页计数 */
        }

    if (pagenbr > 0)
        {
        mempoolhead->mempagedsc[pagenbr - 1].next = NULL;
        mempoolhead->firstfreepagedsc = &(mempoolhead->mempagedsc[0]); /* 指向链表中的第一个 mempagedsc_t */
        goto add_step;
        }

    mempoolhead->mempagedsc[pagenbr].addrstart = NULL;
    mempoolhead->mempagedsc[pagenbr].next      = NULL;

add_step:

    mempoolhead->objtotnbr     = pagenbr;       /* mempoolhead_t 管理的 总的 page 对象 个数 */
    mempoolhead->mempagedscnbr = pagenbr;       /* mempoolhead_t 管理的 mempagedsc_t 个数 */
    list_add (&mempoolhead->list, &kmempool->pagepoolheadlst); /* 初始化 的mempoolhead_t 挂载到 kmempool_t */
    kmempool->pagepoolnbr++;         /* kmempool_t 管理的 pagepool 个数 +1 */

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_create_page_mempoolhead - 创建 mempoolhead_t 并 挂载到 kmempool_t 容器
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_create_page_mempoolhead
    (
    kmempool_t * kmempool,
    size_t       size
    )
    {
    mempoolhead_t *  mempoolhead = NULL;
    size_t           pagenbr     = size >> 12;  /* 1 << 12 = 4096 = 4K = xxx?? */
    addr_t           blkaddr     = NULL;

    /* 要分的 页面个数 */

    if (pagenbr < 1)
        {
        return NULL; /* size 不足以分配一个 page */
        }
    
    /* 
     * 1~2页面 请求 一个 128KB 的块, 3~8页面 请求 一个 256KB 的块;
     * 基于请求的块内存空间 创建 mempoolhead_t 并 初始化 再 挂载到 kmempool_t 容器
     */
    
    if (pagenbr <= 2)
        {
        
        /* 向块级内存管理请求一个 128KB 的块 */
        
        blkaddr = hal_memalloc_blocks (MEMBLK_128KB_SIZE);

        if (blkaddr == NULL)
            {
            return NULL; /* 请求失败 */
            }
        
        mempoolhead = kmempool_page_init (kmempool, (mempoolhead_t *) blkaddr, size,
                                          blkaddr, (blkaddr + MEMBLK_128KB_SIZE - 1));

        if (mempoolhead == NULL)
            {
            krl_system_die ("new page pool err 1\r\n"); /* 系统故障 */
            return NULL;
            }

        return mempoolhead;
        }
    else if (pagenbr <= 4)
        {
        
        /* 向块级内存管理请求一个 256KB 的块 */
        
        blkaddr = hal_memalloc_blocks (MEMBLK_256KB_SIZE);

        if (blkaddr == NULL)
            {
            return NULL; /* 请求失败 */
            }
        
        mempoolhead = kmempool_page_init (kmempool, (mempoolhead_t *) blkaddr, size,
                                          blkaddr, (blkaddr + MEMBLK_256KB_SIZE - 1));

        if (mempoolhead == NULL)
            {
            krl_system_die ("new page pool err 2\r\n"); /* 系统故障 */
            return NULL;
            }

        return mempoolhead;
        }
    else if (pagenbr <= 8)
        {
        
        /* 向块级内存管理请求一个 256KB 的块 */
        
        blkaddr = hal_memalloc_blocks (MEMBLK_256KB_SIZE);

        if (blkaddr == NULL)
            {
            return NULL; /* 请求失败 */
            }
        
        mempoolhead = kmempool_page_init (kmempool, (mempoolhead_t *) blkaddr, size,
                                          blkaddr, (blkaddr + MEMBLK_256KB_SIZE - 1));

        if (mempoolhead == NULL)
            {
            krl_system_die ("new page pool err 3\r\n"); /* 系统故障 */
            return NULL;
            }

        return mempoolhead;
        }
    else if (pagenbr <= 16)
        {
        
        /* 向块级内存管理请求一个 256KB 的块 */
        
        blkaddr = hal_memalloc_blocks (MEMBLK_256KB_SIZE);

        if (blkaddr == NULL)
            {
            return NULL; /* 请求失败 */
            }
        
        mempoolhead = kmempool_page_init (kmempool, (mempoolhead_t *) blkaddr, size,
                                          blkaddr, (blkaddr + MEMBLK_256KB_SIZE - 1));

        if (mempoolhead == NULL)
            {
            krl_system_die ("new page pool err 4\r\n"); /* 系统故障 */
            return NULL;
            }

        return mempoolhead;
        }
    else if (pagenbr <= 31)
        {
        
        /* 向块级内存管理请求一个 128KB 的块 */
        
        blkaddr = hal_memalloc_blocks (MEMBLK_128KB_SIZE);

        if (blkaddr == NULL)
            {
            return NULL; /* 请求失败 */
            }
        
        mempoolhead = kmempool_page_init (kmempool, (mempoolhead_t *) blkaddr, size,
                                          blkaddr, (blkaddr + MEMBLK_128KB_SIZE - 1));

        if (mempoolhead == NULL)
            {
            krl_system_die ("new page pool err 5\r\n"); /* 系统故障 */
            return NULL;
            }

        return mempoolhead;
        }

    /* size 大小超过 页级内存管理 范围 */

    return NULL;
    }


/*********************************************************************************
 * 
 * kmempool_destroy_page_mempoolhead - 摧毁 mempoolhead_t 并 断开 kmempool_t 容器
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_destroy_page_mempoolhead
    (
    kmempool_t *     kmempool,
    mempoolhead_t *  mempoolhead
    )
    {
    
    size_t size;
    addr_t addr;

    /* mempoolhead_t 中还有未被释放的 mempagedsc_t */

    if (mempoolhead->objallocednbr > 0)
        {
        return TRUE; /* 删除内存池的操作是用户不可感知的, 所以也认为该原因导致的删除内存池失败是成功操作 */
        }

    size = mempoolhead->addrend - mempoolhead->addrstart + 1; /* 计算 内存池占用的内存空间大小 */
    addr = mempoolhead->addrstart;                            /* 开始地址记录为释放地址 */

    /* 把 mempoolhead_t 内存池 从 kmempool_t 中删除 */

    list_del (&mempoolhead->list);

    /* 检查页级内存池个数 (如果小于1, 那么内核代码出问题了, 死机)  */
    
    if (kmempool->pagepoolnbr < 1)
        {
        krl_system_die ("kmempool_destroy_page_mempoolhead destroy pagepool err\r\n");
        return FALSE;
        }

    kmempool->pagepoolnbr--;  /* 页级内存池个数 -1 */


    if (kmempool->lastoppagepool == mempoolhead)
        {
        kmempool->lastoppagepool = NULL;  /* 当前的内存池已被删除, 则上次操作的内存池设为 NULL */
        }

    /* 如果 块级内存释放失败, 死机 */

    if (hal_memfree_blocks (addr, size) == FALSE)
        {
        krl_system_die ("kmempool_destroy_page_mempoolhead free blk err\r\n");
        return FALSE;
        }
    
    return TRUE;
    }

/*********************************************************************************
 * 
 * kmempool_byte_init - 创建 mempoolhead_t 并 初始化 再 挂载到 kmempool_t 容器
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_byte_init
    (
    kmempool_t *    kmempool,
    mempoolhead_t * mempoolhead,
    size_t          size,
    addr_t          addrstart,
    addr_t          addrend
    )
    {
    addr_t    ofstaddr;
    uint_t    objnbr = 0;
    addr_t *  nextobjptr;
    addr_t    objsz;
    addr_t    nextobjofst;

    /* 
     * (起始地址不是 KMEMP_ONEPAGE_SZ - 1 字节对齐) 或 
     * (地址区间不足以分配两个页以上 (内核在每个内存池固定占1页)) 
     */

    if (((addrstart & 0xFFF) != 0) || ((addrend - addrstart) < ((KMEMP_ONEPAGE_SZ * 2) - 1)))
        {
        return NULL;
        }
    
    /* 计算 内存池 中 第一个 字节空间的开始地址  */

    ofstaddr = addrstart + sizeof (mempoolhead_t);

    /* 检查是否4字节对齐 */

    if ((ofstaddr & 3) != 0)
        {
        krl_system_die ("kmempool_byte_init: ofstaddr not align dword\r\n");
        return NULL;
        }

    /* mempoolhead_t 结构体初始化 */

    mempoolhead_t_init (mempoolhead);                        /* 默认初始化 */
    mempoolhead->type              = KMEMP_HDTYPE_BYTE;      /* 类型为字节级 */
    mempoolhead->addrstart         = addrstart;              /* 内存池内存起始地址 */
    mempoolhead->addrend           = addrend;                /* 内存池内存结束地址 */
    mempoolhead->firstfreeobjaddr  = ofstaddr;               /* 内存池中第一个对象的地址 */
    mempoolhead->objsz             = size;                   /* 内存池对象 (页) 的大小 */
    mempoolhead->objactlsz         = size;           /* 内存池对象 (页) 的实际大小 (页级中等于objsz) */
    mempoolhead->nextobjofst       = size + sizeof (addr_t); /* 下一个对象指针的偏移量 */

    nextobjptr  = NULL;
    objsz       = mempoolhead->objsz;
    nextobjofst = mempoolhead->nextobjofst;

    /* 如果包含下一个对象指针的偏移量没按4字节对齐, 就停机 */

    if ((mempoolhead->nextobjofst & 3) != 0)
        {
        krl_system_die ("kmempool_byte_init: mempoolhead->nextobjofst not align dword\r\n");
        return NULL;
        }

    /* 将 地址区间的空间 全部映射为 mempoolhead_t 结构体管理的 字节空间 */    

    FOREVER
        {

        /* 剩余空间 不足以分配 size 大小的空间 */

        if ((ofstaddr + nextobjofst - 1) > addrend)
            {
            break;
            }

        nextobjptr  = (addr_t *) (ofstaddr + objsz);  /* 计算 下一个对象 (字节空间) 指针的地址 */
        *nextobjptr = (ofstaddr + nextobjofst);       /* 把下一个对象指针的值放入这个地址的内存单元中 */

        ofstaddr += size;      /* ofstaddr 的值即为下一个对象的开始地址 */
        objnbr++;              /* 该 mempoolhead_t 结构体 管理的内存空间计数 */
        }

    /* 判断该内存池是否有被初始化了的对象 */

    if (objnbr == 0)
        {
        krl_system_die ("kmempool_byte_init: objnbr = 0, err\r\n");
        return NULL;    /* 对象计数为0, 说明没有初始化内存池对象 */
        }

    /* 把最后一个对象的下一个对象指针设为NULL, 表示其后再无对象 */

    ofstaddr   -= nextobjofst;
    nextobjptr  = (addr_t *) (ofstaddr + objsz);
    *nextobjptr = NULL;

    mempoolhead->objtotnbr = objnbr; /* 记录该内存池的对象总个数 */
    
    /* 把内存池 mempoolhead_t 加到 kmempool_t 结构体 */

    list_add (&mempoolhead->list, &kmempool->bytepoolheadlst);
    kmempool->bytepoolnbr++;

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_create_byte_mempoolhead - 创建 mempoolhead_t 并 挂载到 kmempool_t 容器
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_create_byte_mempoolhead
    (
    kmempool_t * kmempool,
    size_t       size
    )
    {
    mempoolhead_t *  mempoolhead = NULL;
    addr_t           pageaddr    = kmempool_pages_new (KMEMP_ONEBYTEPOOL_SZ);

    if (pageaddr == NULL)
        {
        return NULL; /* 申请page失败 */
        }
    
    mempoolhead = (mempoolhead_t *) pageaddr; /* page 转 byte 的 mempoolhead_t */

    /* 初始化一个 字节级内存池 结构体 mempoolhead_t */

    mempoolhead = kmempool_byte_init (kmempool, mempoolhead, size, pageaddr, 
                                      (pageaddr + KMEMP_ONEBYTEPOOL_SZ - 1));
    
    if (mempoolhead == NULL)
        {
        krl_system_die ("new byte pool err 1\r\n"); /* 系统故障 */
        return NULL;
        }

    /* 返回内存池 头 */

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_destroy_byte_mempoolhead - 摧毁 mempoolhead_t 并 断开 kmempool_t 容器
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_destroy_byte_mempoolhead
    (
    kmempool_t *     kmempool,
    mempoolhead_t *  mempoolhead
    )
    {
    
    size_t size;
    addr_t addr;

    /* mempoolhead_t 中还有未被释放的 对象 (字节空间) */

    if (mempoolhead->objallocednbr > 0)
        {
        return TRUE; /* 删除内存池的操作是用户不可感知的, 所以也认为该原因导致的删除内存池失败是成功操作 */
        }

    size = mempoolhead->addrend - mempoolhead->addrstart + 1; /* 计算 内存池占用的内存空间大小 */
    addr = mempoolhead->addrstart;                            /* 开始地址记录为释放地址 */

    /* 把 mempoolhead_t 内存池 从 kmempool_t 中删除 */

    list_del (&mempoolhead->list);

    /* 检查字节级内存池个数 (如果小于1, 那么内核代码出问题了, 死机)  */
    
    if (kmempool->bytepoolnbr < 1)
        {
        krl_system_die ("kmempool_destroy_byte_mempoolhead destroy bytepool err\r\n");
        return FALSE;
        }

    kmempool->bytepoolnbr--;  /* 页级内存池个数 -1 */

    if (kmempool->lastopbytepool == mempoolhead)
        {
        kmempool->lastopbytepool = NULL;  /* 当前的内存池已被删除, 则上次操作的内存池设为 NULL */
        }

    /* 如果 页级内存释放失败, 死机 */

    if (kmempool_pages_delete (addr, size) == FALSE)
        {
        krl_system_die ("kmempool_destroy_byte_mempoolhead free blk err\r\n");
        return FALSE;
        }
    
    return TRUE;
    }

/*
 * DESCRIPTION
 * 
 *              kmempool_new
 *                   ↓
 *          kmempool_onsize_new   ((sz > KMEMP_BYTE_OR_PAGE_SZ) ? R (page level) :
 *              ↙        ↘                                       L (byte level))
 * kmempool_bytes_new    kmempool_pages_new   ((sz > KMEMP_HAL_BLK_SZ) ? L (block level) :
 *                          ↙        ↘                                  R (byte level))
 *    kmempool_pages_new_callhalmm  kmmpool_pages_core_new
 * 
 * 
 *              kmempool_delete
 *                   ↓
 *        kmempool_onsize_delete   ((sz > KMEMP_BYTE_OR_PAGE_SZ) ? R (page level) :
 *              ↙          ↘                                      L (byte level))
 * kmempool_bytes_delete  kmempool_pages_delete   ((sz > KMEMP_HAL_BLK_SZ) ? L (block level) :
 *                          ↙        ↘                                      R (byte level))
 * kmempool_pages_delete_callhalmm  kmmpool_pages_core_delete
 * 
 */

/* routine for new */

/*********************************************************************************
 * 
 * kmempool_new - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_new
    (
    size_t newsz
    )
    {
    addr_t addr;

    /* 1Byte < size < 4MByte */

    if ((newsz < KMEMP_ALCSZ_MIN) || (newsz > KMEMP_ALCSZ_MAX))
        {
        return NULL;
        }

    addr = kmempool_onsize_new (newsz);

    return addr;
    }

/*********************************************************************************
 * 
 * kmempool_onsize_new - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_onsize_new
    (
    size_t newsz
    )
    {
    addr_t addr;

    /* 要分配的内存 size < KMEMP_OBJ_OR_PAGE_SZ, 就使用字节级分配函数 */

    if (newsz > KMEMP_BYTE_OR_PAGE_SZ)
        {
        addr = kmempool_pages_new (newsz);
        }
    else
        {
        addr = kmempool_bytes_new (newsz);
        }

    return addr;
    }


/*********************************************************************************
 * 
 * kmempool_pagenew_check_mempoolhead - 检查一个 mempoolhead_t 结构是否符合分配要求
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_pagenew_check_mempoolhead
    (
    mempoolhead_t * mempoolhead,
    size_t          newsz
    )
    {

    /* 判断 第一个空闲页状态描述结构体 是否为NULL, 为 NULL, 表示被分配完了 */
    
    if (mempoolhead->firstfreepagedsc == NULL)
        {
        return NULL;
        }

    /* 判断该 mempoolhead_t 是否为 页级内存池 */

    if (mempoolhead->type != KMEMP_HDTYPE_PAGE)
        {
        return NULL;
        }

    /* 对象 (页) 实际大小是否与请求大小相等 */

    if (mempoolhead->objactlsz != newsz)
        {
        return NULL;
        }

    /* 对象 (页) 分配计数器 是否小于 总的 对象 (页) 个数 */

    if (mempoolhead->objallocednbr >= mempoolhead->objtotnbr)
        {
        return NULL;
        }

    /* 该内存池 满足分配要求 */

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_pagenew_return_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_pagenew_return_mempoolhead
    (
    kmempool_t * kmempool,
    size_t       newsz
    )
    {
    mempoolhead_t * mempoolhead;
    list_t *        list;

    /* 判断 上次被操作过的 mempoolhead_t 是否符合分配要求 */

    if (kmempool->lastoppagepool != NULL)
        {
        mempoolhead = kmempool->lastoppagepool;

        /* 判断 mempoolhead 是否符合分配要求 */

        mempoolhead = kmempool_pagenew_check_mempoolhead (mempoolhead, newsz);

        if (mempoolhead != NULL)
            {
            return mempoolhead;  /* 符合分配要求 */
            }
        }

    /* 在未被操作过的 page mempoolhead_t 结构体 中找到满足分配条件的 mempoolhead */

    list_for_each (list, &kmempool->pagepoolheadlst)
        {
        mempoolhead = list_entry (list, mempoolhead_t, list);

        /* 判断 mempoolhead 是否符合分配要求 */

        mempoolhead = kmempool_pagenew_check_mempoolhead (mempoolhead, newsz);

        if (mempoolhead != NULL)
            {

            /* 保存到上次被操作, 下次分配前减少查找时间 */

            kmempool->lastoppagepool = mempoolhead;  

            return mempoolhead;  /* 符合分配要求 */
            }
        }
    
    /* 没有合适的 mempoolhead_t 结构体 满足分配要求 */

    return NULL;
    }

/*********************************************************************************
 * 
 * kmempool_pagenew_on_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_pagenew_on_mempoolhead
    (
    mempoolhead_t * mempoolhead
    )
    {
    addr_t         addr;
    mempagedsc_t * mempagedsc;

    /* 该 mempoolhead_t 结构是否已被分配完毕 */

    if (mempoolhead->objallocednbr >= mempoolhead->objtotnbr)
        {
        return NULL;
        }

    /* 判断 mempoolhead_t 中 是否存在空闲的 mempagedsc_t 结构 */

    if (mempoolhead->firstfreepagedsc != NULL)
        {
        mempagedsc = mempoolhead->firstfreepagedsc;
        mempoolhead->firstfreepagedsc = mempagedsc->next; /* 指向下一个 free mempagedsc_t */
        mempagedsc->next = NULL;          /* 把当前空闲 mempagedsc_t 的 next 域设为 NULL */
        mempoolhead->objallocednbr++;     /* mempoolhead_t 结构体已分配 对象 (页) +1 */

        addr = mempagedsc->addrstart;     /* 返回空闲页面的首地址 */
        return addr;
        }

    /* 该 mempoolhead_t 结构中 无空闲 mempagedsc_t 结构 */

    return NULL;
    }

/*********************************************************************************
 * 
 * kmempool_pages_new - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_pages_new
    (
    size_t newsz
    )
    {
    addr_t addr;
    size_t sz = KMEMP_BYTE_ALIGN (newsz);

    /* sz > 最大分配页面字节数 则使用块分配 */

    if (sz > KMEMP_HAL_BLK_SZ)
        {
        addr = kmempool_pages_new_callhalmm (sz);
        }
    else
        {
        addr = kmempool_pages_core_new (sz);
        }
    
    return addr;
    }

/*********************************************************************************
 * 
 * kmempool_pages_new_callhalmm - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_pages_new_callhalmm
    (
    size_t newsz
    )
    {
    addr_t addr = NULL;

    if (newsz <= MEMBLK_128KB_SIZE)
        {
        addr = hal_memalloc_blocks (MEMBLK_128KB_SIZE);
        }
    else if (newsz <= MEMBLK_256KB_SIZE)
        {
        addr = hal_memalloc_blocks (MEMBLK_256KB_SIZE);
        }
    else if (newsz <= MEMBLK_512KB_SIZE)
        {
        addr = hal_memalloc_blocks (MEMBLK_512KB_SIZE);
        }
    else if (newsz <= MEMBLK_1MB_SIZE)
        {
        addr = hal_memalloc_blocks (MEMBLK_1MB_SIZE);
        }
    else if (newsz <= MEMBLK_2MB_SIZE)
        {
        addr = hal_memalloc_blocks (MEMBLK_2MB_SIZE);
        }
    else if (newsz <= MEMBLK_4MB_SIZE)
        {
        addr = hal_memalloc_blocks (MEMBLK_4MB_SIZE);
        }

    return addr;
    }

/*********************************************************************************
 * 
 * kmempool_pages_core_new - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_pages_core_new
    (
    size_t newsz
    )
    {
    cpuflg_t        cpuflg;
    mempoolhead_t * mempoolhead;
    addr_t          addr;
    kmempool_t *    kmempool = &oskmempool;

    /* 对 kmempool_t 结构 加锁 */

    spinlock_saveflg_cli (&kmempool->pagelock, &cpuflg);

    /* 遍历 查找符合分配条件的 mempoolhead_t 内存池 */

    mempoolhead = kmempool_pagenew_return_mempoolhead (kmempool, newsz);

    if (mempoolhead == NULL)
        {
        
        /* 新建 mempoolhead_t 内存池 */

        mempoolhead = kmempool_create_page_mempoolhead (kmempool, newsz);

        if (mempoolhead == NULL)
            {
            addr = NULL;        /* 创建失败 */
            goto return_step;
            }
        }

    /* 查找到 一个符合分配条件 的 mempoolhead_t 内存池, 基于该内存池完成页面分配 */

    addr = kmempool_pagenew_on_mempoolhead (mempoolhead);   /* 也可能分配失败 */

return_step:

    /* 对 kmempool_t 结构 解锁 */
    spinunlock_restflg_sti (&kmempool->pagelock, &cpuflg);

    return addr;
    }

/*********************************************************************************
 * 
 * kmempool_bytenew_check_mempoolhead - 检查一个 mempoolhead_t 结构是否符合分配要求
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_bytenew_check_mempoolhead
    (
    mempoolhead_t * mempoolhead,
    size_t          newsz
    )
    {

    /* 判断有无内存池对象 */
    
    if (mempoolhead->firstfreeobjaddr == NULL)
        {
        return NULL;
        }

    /* 判断该 mempoolhead_t 是否为 字级内存池 */

    if (mempoolhead->type != KMEMP_HDTYPE_BYTE)
        {
        return NULL;
        }

    /* 对象 空间 实际大小是否与请求大小相等 */

    if (mempoolhead->objactlsz != newsz)
        {
        return NULL;
        }

    /* 对象 空间 分配计数器 是否小于 总的 对象 空间 个数 */

    if (mempoolhead->objallocednbr >= mempoolhead->objtotnbr)
        {
        return NULL;
        }

    /* 该内存池 满足分配要求 */

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_bytenew_return_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_bytenew_return_mempoolhead
    (
    kmempool_t * kmempool,
    size_t       newsz
    )
    {
    mempoolhead_t * mempoolhead;
    list_t *        list;

    /* 判断 上次被操作过的 mempoolhead_t 是否符合分配要求 */

    if (kmempool->lastopbytepool != NULL)
        {
        mempoolhead = kmempool->lastopbytepool;

        /* 判断 mempoolhead 是否符合分配要求 */

        mempoolhead = kmempool_bytenew_check_mempoolhead (mempoolhead, newsz);

        if (mempoolhead != NULL)
            {
            return mempoolhead;  /* 符合分配要求 */
            }
        }

    /* 在未被操作过的 byte mempoolhead_t 结构体 中找到满足分配条件的 mempoolhead */

    list_for_each (list, &kmempool->bytepoolheadlst)
        {
        mempoolhead = list_entry (list, mempoolhead_t, list);

        /* 判断 mempoolhead 是否符合分配要求 */

        mempoolhead = kmempool_bytenew_check_mempoolhead (mempoolhead, newsz);

        if (mempoolhead != NULL)
            {

            /* 保存到上次被操作, 下次分配前减少查找时间 */

            kmempool->lastopbytepool = mempoolhead;  

            return mempoolhead;  /* 符合分配要求 */
            }
        }
    
    /* 没有合适的 mempoolhead_t 结构体 满足分配要求 */

    return NULL;
    }

/*********************************************************************************
 * 
 * kmempool_bytenew_on_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_bytenew_on_mempoolhead
    (
    mempoolhead_t * mempoolhead
    )
    {
    addr_t         addr       = NULL;
    addr_t *       nextobjptr = NULL;         
    addr_t         objsz      = (addr_t) (mempoolhead->objactlsz);

    /* 该 mempoolhead_t 结构是否已被分配完毕 */

    if (mempoolhead->objallocednbr >= mempoolhead->objtotnbr)
        {
        return NULL;
        }

    /* 判断 mempoolhead_t 中 是否存在空闲的 字节空间 */

    if (mempoolhead->firstfreeobjaddr != NULL)
        {
        addr        = mempoolhead->firstfreeobjaddr;    /* addr = 当前空闲对象 (字节空间) 的地址 */
        nextobjptr  = (addr_t *) (addr + objsz);        /* nextobjptr 指向当前对象的下一个对象 */
        mempoolhead->firstfreeobjaddr = *nextobjptr;    /* firstfreeobjaddr 指向 nextobjptr */
        *nextobjptr = NULL;                       /* 把当前对象的下一个对象指针域设为NULL (断开链表) */

        mempoolhead->objallocednbr++;     /* mempoolhead_t 结构体已分配 对象 (字节空间) +1 */

        return addr;
        }

    /* 该 mempoolhead_t 结构中 无空闲 字节空间 */

    return NULL;
    }

/*********************************************************************************
 * 
 * kmempool_bytes_new - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_bytes_new 
    (
    size_t newsz
    )
    {
    addr_t addr;
    size_t size = KMEMP_BYTE_ALIGN (newsz);

    if (size > KMEMP_ONEPAGE_SZ)
        {
        return NULL; /* 超过字节管理的最大 字节数 */
        }

    addr = kmempool_bytes_core_new (newsz);

    return addr;
    }

/*********************************************************************************
 * 
 * kmempool_bytes_core_new - 
 * 
 * DESCRIPTION
 * 
 */

addr_t kmempool_bytes_core_new 
    (
    size_t newsz
    )
    {
    addr_t          addr = NULL;
    cpuflg_t        cpuflg;
    mempoolhead_t * mempoolhead;
    kmempool_t *    kmempool = &oskmempool;

    /* 对 kmempool_t 结构加锁 */

    spinlock_saveflg_cli (&kmempool->bytelock, &cpuflg);

    /* 遍历 查找符合分配条件的 mempoolhead_t 内存池 */

    mempoolhead = kmempool_bytenew_return_mempoolhead (kmempool, newsz);

    if (mempoolhead == NULL)
        {

        /* 未找到 合适 的 mempoolhead_t 内存池 */

        mempoolhead = kmempool_create_byte_mempoolhead (kmempool, newsz);

        if (mempoolhead == NULL)
            {
            addr = NULL;
            goto return_step;   /* 创建 字节级内存池 失败 */
            }
        }

    /* 操作 mempoolhead 完成 字节内存空间的分配 */

    addr = kmempool_bytenew_on_mempoolhead (mempoolhead);

return_step:

    /* 对 kmempool_t 结构解锁 */

    spinunlock_restflg_sti (&kmempool->bytelock, &cpuflg);

    return addr;
    }

/* routine for free */

/*********************************************************************************
 * 
 * kmempool_delete - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_delete
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    bool_t status;

    /* 1Byte < size < 4MByte */

    if ((deladdr == NULL) || (delsz < KMEMP_ALCSZ_MIN) || (delsz > KMEMP_ALCSZ_MAX))
        {
        return NULL;
        }

    status = kmempool_onsize_delete (deladdr, delsz);

    return status;
    }

/*********************************************************************************
 * 
 * kmempool_onsize_delete - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_onsize_delete
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    bool_t status;

    /* 要释放的内存 size < KMEMP_OBJ_OR_PAGE_SZ, 就使用字节级释放函数 */

    if (delsz > KMEMP_BYTE_OR_PAGE_SZ)
        {
        status = kmempool_pages_delete (deladdr, delsz);
        }
    else
        {
        status = kmempool_bytes_delete (deladdr, delsz);
        }

    return status;
    }

/*********************************************************************************
 * 
 * kmempool_pagedel_check_mempoolhead - 检查一个 mempoolhead_t 结构是否符合释放要求
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_pagedel_check_mempoolhead
    (
    mempoolhead_t * mempoolhead,
    addr_t          deladdr,
    size_t          delsz
    )
    {

    /* 是否为页级内存池 */

    if (mempoolhead->type != KMEMP_HDTYPE_PAGE)
        {
        return NULL;
        }

    /* 实际对象 (页) 大小是否和 页面释放 大小相同 */

    if (mempoolhead->objactlsz != delsz)
        {
        return NULL;
        }

    /* mempoolhead_t 结构体 是否有被分配 */

    if (mempoolhead->objallocednbr == 0)
        {
        return NULL;    /* 未被分配, 不能被释放 */
        }
    
    /* 释放的地址, 是否在这个内存池中 */

    if ((deladdr < (mempoolhead->addrstart + KMEMP_ONEPAGE_SZ)) || 
        ((deladdr + delsz - 1) > mempoolhead->addrend))
        {
        return NULL;
        }

    /* 该 mempoolhead_t 符合释放要求 */

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_pagedel_return_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_pagedel_return_mempoolhead
    (
    kmempool_t * kmempool,
    addr_t       deladdr,
    size_t       delsz
    )
    {
    mempoolhead_t * mempoolhead;
    list_t *        list;

    /* 判断 上次被操作过的 mempoolhead_t 是否符合释放要求 */

    if (kmempool->lastoppagepool != NULL)
        {
        mempoolhead = kmempool->lastoppagepool;

        /* 判断 mempoolhead 是否符合释放要求 */

        mempoolhead = kmempool_pagedel_check_mempoolhead (mempoolhead, deladdr, delsz);

        if (mempoolhead != NULL)
            {
            return mempoolhead;  /* 符合释放要求 */
            }
        }

    /* 在未被操作过的 mempoolhead_t 结构体 中找到满足释放条件的 mempoolhead */

    list_for_each (list, &kmempool->pagepoolheadlst)
        {
        mempoolhead = list_entry (list, mempoolhead_t, list);

        /* 判断 mempoolhead 是否符合释放要求 */

        mempoolhead = kmempool_pagedel_check_mempoolhead (mempoolhead, deladdr, delsz);

        if (mempoolhead != NULL)
            {
            return mempoolhead;  /* 符合释放要求 */
            }
        }
    
    /* 没有合适的 mempoolhead_t 结构体 满足释放要求 */

    return NULL;
    }

/*********************************************************************************
 * 
 * kmempool_pagedel_on_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_pagedel_on_mempoolhead
    (
    mempoolhead_t * mempoolhead,
    addr_t          deladdr
    )
    {
    mempagedsc_t * mempagedsc;
    uint_t         i;

    /*
     * mempoolhead_t 结构体中
     * 已被分配的对象 (页) 计数 < 1, 表示没有分配过
     * mempagedsc_t 结构体计数 < 1, 表示没有 mempagedsc_t 结构体
     */

    if ((mempoolhead->objallocednbr < 1) || (mempoolhead->mempagedscnbr < 1))
        {
        return FALSE;
        }

    /*
     * 搜索 mempoolhead_t 中的所有 mempagedsc_t 结构体
     * addr == mempagedsc_t->addrstart 时表示找到要释放 的 mempagedsc_t
     */

    for (i = 0; i < mempoolhead->mempagedscnbr; i++)
        {
        if (deladdr == mempoolhead->mempagedsc[i].addrstart)
            {
            mempagedsc = &mempoolhead->mempagedsc[i];

            /*  */

            if (mempagedsc->next != NULL)
                {
                return FALSE;
                }

            goto del_step;
            }
        }

    /* 没在 mempoolhead_t 结构体中找到 mempagedsc_t */

    return FALSE;

del_step:

    mempagedsc->next = mempoolhead->firstfreepagedsc;

    /* 把 mempagedsc 放进 firstfreepagedsc 链表中 */

    mempoolhead->firstfreepagedsc = mempagedsc;

    /* 减少分配计数, 表示释放了一个对象 (页面) */

    mempoolhead->objallocednbr--;

    return TRUE;
    }



/*********************************************************************************
 * 
 * kmempool_pages_delete - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_pages_delete
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    bool_t status;

    size_t sz = KMEMP_BYTE_ALIGN (delsz);

    /* sz > 最大分配页面字节数 则使用块释放 */

    if (sz > KMEMP_HAL_BLK_SZ)
        {
        status = kmempool_pages_delete_callhalmm (deladdr, sz);
        }
    else
        {
        status = kmmpool_pages_core_delete (deladdr, sz);
        }
    
    return status;
    }

/*********************************************************************************
 * 
 * kmempool_pages_delete_callhalmm - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_pages_delete_callhalmm
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    bool_t status;

    if (delsz <= MEMBLK_128KB_SIZE)
        {
        status = hal_memfree_blocks (deladdr, MEMBLK_128KB_SIZE);
        }
    else if (delsz <= MEMBLK_256KB_SIZE)
        {
        status = hal_memfree_blocks (deladdr, MEMBLK_256KB_SIZE);
        }
    else if (delsz <= MEMBLK_512KB_SIZE)
        {
        status = hal_memfree_blocks (deladdr, MEMBLK_512KB_SIZE);
        }
    else if (delsz <= MEMBLK_1MB_SIZE)
        {
        status = hal_memfree_blocks (deladdr, MEMBLK_1MB_SIZE);
        }
    else if (delsz <= MEMBLK_2MB_SIZE)
        {
        status = hal_memfree_blocks (deladdr, MEMBLK_2MB_SIZE);
        }
    else if (delsz <= MEMBLK_4MB_SIZE)
        {
        status = hal_memfree_blocks (deladdr, MEMBLK_4MB_SIZE);
        }
        
    return deladdr;
    }

/*********************************************************************************
 * 
 * kmmpool_pages_core_delete - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmmpool_pages_core_delete
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    cpuflg_t        cpuflg;
    bool_t          status = FALSE;
    mempoolhead_t * mempoolhead;
    kmempool_t *    kmempool = &oskmempool;

    /* 对 kmempool_t 结构 加锁 */

    spinlock_saveflg_cli (&kmempool->pagelock, &cpuflg);

    /* 查找是否有 满足要求的 mempoolhead_t 结构体 */

    mempoolhead = kmempool_pagedel_return_mempoolhead (kmempool, deladdr, delsz);

    if (mempoolhead == NULL)
        {
        status = FALSE;   /* 没有合适的 mempoolhead_t 结构体 满足释放要求 */
        goto return_step;
        }

    /* 释放 mempoolhead 指定的内存池中的页面 */

    if (kmempool_pagedel_on_mempoolhead (mempoolhead, deladdr) == FALSE)
        {
        status = FALSE;   /* 释放 页面 失败 */
        goto return_step;        
        }
    
    /* (尝试) 删除 mempoolhead 指定的内存池  */

    if (kmempool_destroy_page_mempoolhead (kmempool, mempoolhead) == FALSE)
        {
        status = FALSE;   /* 删除内存池 失败 */
        goto return_step;           
        }

    /* 释放成功 */

    return TRUE;

return_step:

    spinunlock_restflg_sti (&kmempool->pagelock, &cpuflg);

    return status;
    }

/*********************************************************************************
 * 
 * kmempool_bytedel_check_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_bytedel_check_mempoolhead 
    (
    mempoolhead_t * mempoolhead, 
    addr_t          deladdr, 
    size_t          delsz
    )
    {
    /* 是否为字节级内存池 */

    if (mempoolhead->type != KMEMP_HDTYPE_BYTE)
        {
        return NULL;
        }

    /* 实际对象 (字节空间) 大小是否和 被字节释放空间 大小相同 */

    if (mempoolhead->objactlsz != delsz)
        {
        return NULL;
        }

    /* mempoolhead_t 结构体 是否有被分配 */

    if (mempoolhead->objallocednbr == 0)
        {
        return NULL;    /* 未被分配, 不能被释放 */
        }
    
    /* 释放的地址, 是否在这个内存池中 */

    if ((deladdr < (mempoolhead->addrstart + sizeof (mempoolhead_t))) || 
        ((deladdr + delsz - 1) > mempoolhead->addrend))
        {
        return NULL;
        }

    /* 该 mempoolhead_t 符合释放要求 */

    return mempoolhead;
    }

/*********************************************************************************
 * 
 * kmempool_bytedel_return_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

mempoolhead_t * kmempool_bytedel_return_mempoolhead 
    (
    kmempool_t * kmempool,
    addr_t       deladdr,
    size_t       delsz
    )
    {
    mempoolhead_t * mempoolhead;
    list_t *        list;

    /* 判断 上次被操作过的 mempoolhead_t 是否符合释放要求 */

    if (kmempool->lastopbytepool != NULL)
        {
        mempoolhead = kmempool->lastopbytepool;

        /* 判断 mempoolhead 是否符合释放要求 */

        mempoolhead = kmempool_bytedel_check_mempoolhead (mempoolhead, deladdr, delsz);

        if (mempoolhead != NULL)
            {
            return mempoolhead;  /* 符合释放要求 */
            }
        }

    /* 在未被操作过的 mempoolhead_t 结构体 中找到满足释放条件的 mempoolhead */

    list_for_each (list, &kmempool->bytepoolheadlst)
        {
        mempoolhead = list_entry (list, mempoolhead_t, list);

        /* 判断 mempoolhead 是否符合释放要求 */

        mempoolhead = kmempool_bytedel_check_mempoolhead (mempoolhead, deladdr, delsz);

        if (mempoolhead != NULL)
            {
            return mempoolhead;  /* 符合释放要求 */
            }
        }
    
    /* 没有合适的 mempoolhead_t 结构体 满足释放要求 */

    return NULL;
    }

/*********************************************************************************
 * 
 * kmempool_bytedel_on_mempoolhead - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_bytedel_on_mempoolhead 
    (
    mempoolhead_t * mempoolhead, 
    addr_t          deladdr
    )
    {
    addr_t         addr       = NULL;
    addr_t *       nextobjptr = NULL;         
    addr_t         objsz      = (addr_t) (mempoolhead->objactlsz);

    /*
     * mempoolhead_t 结构体中
     * 已被分配的对象 (字节空间) 计数 < 1, 表示没有分配过
     * 被释放的地址是否落在该内存池地址区间
     */

    if ((mempoolhead->objallocednbr < 1) || 
        (deladdr < (mempoolhead->addrstart + sizeof (mempoolhead_t))) ||
        ((deladdr + mempoolhead->objactlsz) >= mempoolhead->addrend))
        {
        return FALSE;
        }

    /* 计算释放对象 (字节空间) 下一个对象指针域的地址 */

    nextobjptr = (addr_t *) (deladdr + objsz);

    if (*nextobjptr != NULL)
        {
        return FALSE;   /* 释放对象 (字节空间) 的下一个对象指针域为 NULL */
        }

    addr        = mempoolhead->firstfreeobjaddr;    /* addr = 当前空闲对象 (字节空间) 的地址 */
    mempoolhead->firstfreeobjaddr = deladdr;        /* firstfreeobjaddr 指向 deladdr */
    *nextobjptr = addr;     /* 将之前 firstfreeobjaddr 域的值赋值给释放对象的下一个对象指针 (挂入链表) */

    mempoolhead->objallocednbr--;                  /* mempoolhead_t 结构体已分配 对象 (字节空间) -1 */

    return TRUE;
    }

/*********************************************************************************
 * 
 * kmempool_bytes_delete - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmempool_bytes_delete 
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    bool_t ret;
    size_t size = KMEMP_BYTE_ALIGN (delsz);

    if (size > KMEMP_BYTE_OR_PAGE_SZ)
        {
        return FALSE;
        }

    ret = kmmpool_bytes_core_delete (deladdr, delsz);

    return ret;
    }

/*********************************************************************************
 * 
 * kmmpool_bytes_core_delete - 
 * 
 * DESCRIPTION
 * 
 */

bool_t kmmpool_bytes_core_delete 
    (
    addr_t deladdr,
    size_t delsz
    )
    {
    bool_t          status = FALSE;
    cpuflg_t        cpuflg;
    mempoolhead_t * mempoolhead;
    kmempool_t *    kmempool = &oskmempool;

    /* 保护 kmempool_t 结构 字节级内存池 上锁 */

    spinlock_saveflg_cli (&kmempool->bytelock, &cpuflg);

    /* 获得满足释放条件的 mempoolhead_t 结构体 */

    mempoolhead = kmempool_bytedel_return_mempoolhead (kmempool, deladdr, delsz);

    if (mempoolhead == NULL)
        {
        status = FALSE;
        goto return_step;   /* 未找到 合适的 mempoolhead_t 结构体 */
        }

    /* 释放字节级内存池的内存块 */

    if (kmempool_bytedel_on_mempoolhead (mempoolhead, delsz) == FALSE)
        {
        status = FALSE;
        goto return_step;   /* 该 mempoolhead_t 结构体 不符合 释放条件*/        
        }

    /* 释放内存池自身占用的物理内存空间 */

    if (kmempool_destroy_byte_mempoolhead (kmempool, mempoolhead) == FALSE)
        {
        status = FALSE;
        goto return_step;   /* 删除 该 mempoolhead_t 字节级内存池失败*/            
        }

    status = TRUE;

return_step:

    /* 保护 kmempool_t 结构 字节级内存池 解锁 */

    spinunlock_restflg_sti (&kmempool->bytelock, &cpuflg);

    return status;
    }